package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.Item_CatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ItemCatServiceImpl implements ItemCatService{
    @Autowired
    private Item_CatMapper item_catMapper;
//1.准备Map集合实现数据封装
    /**
     * Map<key,value> = Map<parentId,List<ItemCat>>
     *     2.封装的业务说明：
     *     map中key~~parentId 不存在可以存储该key
     *     设定key 同时封装一个list集合，将自己作为第一元素封装到其中。
     *     存在：根据key获取所有的子级集合，将自己追加进去，形成第二个元素
     * BUG：
     */

    public Map<Integer,List<ItemCat>> itemCatMap(){
        //1.定义我们Map集合
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //2.查询所有的数据库信息 1-2-3
        List<ItemCat> list = item_catMapper.selectList(null);
        for (ItemCat itemCat :list){
            int parentId = itemCat.getParentId();
            if (map.containsKey(parentId)){
                //有key，获取list集合 将自己追加到集合中
                List<ItemCat> list2 = map.get(parentId);//引用对象
                list2.add(itemCat);
            }else {
                //没有key,将自己封装为第一个list元素
                List<ItemCat> list1 = new ArrayList<>();
                list1.add(itemCat);
                map.put(parentId, list1);
            }
        }
        return map;
    }
    @Override
    @Transactional
    public List<ItemCat> findItemCatList(Integer level) {
        long s = System.currentTimeMillis();
        Map<Integer,List<ItemCat>> map =  itemCatMap();
        //1.如果level=1说明获取1级商品分类信息
        if (level ==1){
            return map.get(0);
        }
        if (level ==2){
           return getTowList(map);
        }
        //3.获取三级菜单信息
        //3.1获取二级商品分类信息 有的数据没有子级 如何处理
        List<ItemCat> oneList = getTowList(map);
        for (ItemCat oneItemCat : oneList){
            List<ItemCat> towList = oneItemCat.getChildren();
            //bug解决：如果该元素没有二级列表则跳过本次循环，执行下一次操作
            if(towList == null || towList.size()==0){
                continue;//跳过本次执行下一次 break直接终止

            }
            for (ItemCat towListCat :towList){
                List<ItemCat> threeList = map.get(towListCat.getId());
                towListCat.setChildren(threeList);
            }

        }
         long e = System.currentTimeMillis();
        System.out.println("时间为"+(e-s)+"毫秒");
        return oneList;
    }

    @Override
    @Transactional
    public void updateStatus(ItemCat itemCat) {
        item_catMapper.updateById(itemCat);
    }

    @Override
    @Transactional
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);
        item_catMapper.insert(itemCat);
    }
      /**
       * 策略：如果是父级。则应该删除子级*/
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        //1.判断是否为3级菜单
        if (itemCat.getLevel() ==3){
            //如果是3级。则直接删除
            item_catMapper.deleteById(itemCat.getId());
            return;//程序终止
        }
        //2.检查菜单是否为2级
        if(itemCat.getLevel()==2){
            //应该先删除3级 根据parent_id = 2级id即可
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.eq("parent_id", itemCat.getId());
            item_catMapper.delete(queryWrapper);
            //在删除2级菜单
            item_catMapper.deleteById(itemCat.getId());
            return;
        }
        //删除1级商品分类
        //1.首先获取二级信息
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("parent_id", itemCat.getId());
        List<ItemCat> towList = item_catMapper.selectList(queryWrapper);
        for (ItemCat towItemCat : towList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id", towItemCat.getId());
            item_catMapper.delete(queryWrapper);//删除3级菜单
            item_catMapper.deleteById(towItemCat.getId());//删除2级菜单
        }
        item_catMapper.deleteById(itemCat.getId());

    }

    @Override
    public void updateItemCat(ItemCat itemCat) {
        item_catMapper.updateById(itemCat);
    }


    public List<ItemCat> getTowList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> oneList = map.get(0);
        for (ItemCat oneItemCat : oneList){
            List<ItemCat> towList =  map.get(oneItemCat.getId());
            oneItemCat.setChildren(towList);
        }
        //2.二级嵌套在一级的集合中所以永远返回的都是一级
        return oneList;
    }









    /**
     * 3层商品的分类 1级分类（children（2级商品分类）
     *              2级分类（children（3级商品分类）））
     * 一级查询条件 parent_id=0
     * 一级查询条件 parent_id=二级id
     * 一级查询条件 parent_id=三级id*/
   /* @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long s = System.currentTimeMillis();
        //1.查询一级
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("parent_id", 0);
        List<ItemCat> oneList = item_catMapper.selectList(queryWrapper);
        //2.查询2级
        for(ItemCat oneItemCat : oneList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id", oneItemCat.getId());
            List<ItemCat> towList = item_catMapper.selectList(queryWrapper);
            //3.查询3级商品分类
            for (ItemCat towItemCat :towList){
                queryWrapper.clear();
                queryWrapper.eq("parent_id", towItemCat.getId());
                List<ItemCat> ThreeList = item_catMapper.selectList(queryWrapper);
                towItemCat.setChildren(ThreeList);
            }
            oneItemCat.setChildren(towList);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("业务执行时间为"+(endTime-s)+"毫秒");
        return oneList;
    }*/
}
